package org.jeecg.modules.upgrade.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.classes.entity.CouClass;
import org.jeecg.modules.classes.mapper.UpGradeRiseMapper;
import org.jeecg.modules.upgrade.po.UpGradeRise;
import org.jeecg.modules.classes.service.ICouClassService;
import org.jeecg.modules.upgrade.service.IUpGradeRiseService;
import org.jeecg.modules.grade.entity.CouGrade;
import org.jeecg.modules.grade.service.ICouGradeService;
import org.jeecg.modules.relation.relclssubtearoom.entity.RelClassSubjectTeacher;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.ArrayList;
import java.util.List;

public class UpGradeRiseServiceImpl extends ServiceImpl<UpGradeRiseMapper, UpGradeRise>  implements IUpGradeRiseService {
    @Autowired
    private ICouClassService couClassService;
    @Autowired
    private ICouGradeService couGradeService;
    /**
     * 批量升级班级到新的年级：批量改名，把班级名称批量替换
     * @param upGradeRise:sourceclassids 班级ids列表 targetGradeId 目标年级id
     * @return
     */
    @Override
    public boolean upGradeRiseClass2NewGrade(UpGradeRise upGradeRise){
        //年级和届级有一个为空，且班级id的list为空，则无法执行
        if((oConvertUtils.isEmpty(upGradeRise.getSourceGradeId()) || oConvertUtils.isNotEmpty(upGradeRise.getClassGradesessionYearCode()) ) && oConvertUtils.listIsEmpty(upGradeRise.getSourceClassIds())){
            return  false;
        }
        //年级和届级不为空，则用年级和届级查询所有的班级赋值给班级id的list
        CouGrade oldCouGrade;
        List<CouClass> couClassLists;
        if(oConvertUtils.isNotEmpty(upGradeRise.getSourceGradeId()) &&oConvertUtils.isNotEmpty(upGradeRise.getClassGradesessionYearCode()) && oConvertUtils.listIsEmpty(upGradeRise.getSourceClassIds())){
            oldCouGrade = couGradeService.getById(upGradeRise.getSourceGradeId());
            CouClass couClassTemp = new CouClass();
            couClassTemp.setGradeCode(upGradeRise.getSourceGradeId());
            couClassTemp.setClassGradesessionYear(upGradeRise.getClassGradesessionYearCode());
            couClassLists = couClassService.queryAll(couClassTemp);
            List<String> classIdList = new ArrayList<>();
            for(CouClass couClassOne :couClassLists){
                classIdList.add(couClassOne.getId());
            }
            upGradeRise.setSourceClassIds(classIdList);
        }
        else{
            couClassLists = couClassService.listByIds(upGradeRise.getSourceClassIds());
            //如果班级列表为空，则无法升级
            if( oConvertUtils.listIsEmpty(couClassLists)){
                return  false;
            }
            oldCouGrade = couGradeService.getById(couClassLists.get(0).getGradeCode());

            upGradeRise.setTargetGradeId(couClassLists.get(0).getGradeCode());
            upGradeRise.setClassGradesessionYearCode(couClassLists.get(0).getClassGradesessionYear());
            //如果所选班级不是同一个年级、同一个届级，则无法继续升级
            for(CouClass couClassOne :couClassLists){
               if(! upGradeRise.getTargetGradeId().equals(couClassOne.getGradeCode()) || ! upGradeRise.getClassGradesessionYearCode().equals(couClassOne.getClassGradesessionYear()) ){
                   return false;
                };
            }
        }

        CouGrade newCouGrade = couGradeService.getById(upGradeRise.getTargetGradeId());
        List<CouClass> newCouClassList = new ArrayList<CouClass>();

        //如果班级id为空，则无法升级,新的年级不存在则无法升级
        if( oConvertUtils.listIsEmpty(upGradeRise.getSourceClassIds()) || oConvertUtils.isEmpty(newCouGrade)){
            return  false;
        }
        //如果新升级的目标年级与现有年级相同，则要考虑是否需要继续升级，常见七年级升级为七年级来规范数据，同级升级规范数据
        //升级前后年级相同，且强制执行，且覆盖执行，则继续
        //升级前后年级相同，且(不是强制执行，不是覆盖执行），则结束升级
        if(newCouGrade.getId().equals(oldCouGrade.getId()) &&(!upGradeRise.getIzForce() && !upGradeRise.getIzCoverOrReCreate()) ){
            //相同年级，无需继续升级（无需数据标准化，如果需要标准化则要IzForce=true强制且允许覆盖）。同年级不创建新的）
            return false;
        }


        for(CouClass couClass : couClassLists) {
            String className = couClassService.getNewClassNameByClassNumber(couClass);
            //判断是否已升级，未升级过则执行升级，避免重复执行，升级过则需要校验强制升级标识
            if(  couClass.getClassName().indexOf(newCouGrade.getGradeName()) >=0 || couClass.getClassNickname().indexOf(newCouGrade.getGradeAbbreviation()) >=0 ) {
                //名称已有年级信息，简称也有年级简称信息 说明已经升级过无需再次升级（除非强制重命名）
                if(upGradeRise.getIzForce() ){
                    //强制升级(对班级重命名)，强制重命名
                    //需要强制重命名
                    couClass.setClassName(newCouGrade.getGradeName()+className);
                    couClass.setClassNickname(newCouGrade.getGradeAbbreviation()+className);
                }
            }
            else{
                //更新班级的名称和简称
                couClass.setClassName(newCouGrade.getGradeName()+className);
                couClass.setClassNickname(newCouGrade.getGradeAbbreviation()+className);
            }


            couClass.setGradeCode(upGradeRise.getTargetGradeId());
            couClass.setSchoolYearId(upGradeRise.getTargetSchoolYearId());
            couClass.setSemesterId(upGradeRise.getTargetSemesterId());
            if(upGradeRise.getIzCopy()){
                //判断同名、同级、同学期班级是否存在
                List<CouClass> couClassListsFromDB = couClassService.queryAll(couClass);
                if(oConvertUtils.listIsNotEmpty(couClassListsFromDB)){
                    //已存在相同的数据，则判断是否需要覆盖
                    if(upGradeRise.getIzCoverOrReCreate()){
                        //直接覆盖原有数据：常见七年级升级为七年级来规范数据，同级升级规范数据
                        newCouClassList.add(couClass);
                        continue;
                    }
                    else {
                        //已有数据不覆盖要复制创建，把原有数据设置为删除状态，新建数据
                        couClass.setClassIzDelete(1);
                        couClassService.updateById(couClass);//更新数据为删除状态
                        couClass.setId(null);//把id设置为null，在save时候自动insert
                        newCouClassList.add(couClass);
                    }

                }

                //是否复制：true 复制班级数据
                couClass.setId(null);//把id设置为null，在save时候自动insert
            }
            //记录到list中统一入库
            newCouClassList.add(couClass);

        }
        //循环结束，批量保存入库：批量升级操作--班级
        couClassService.saveBatch(newCouClassList);

        //全部执行成功
        return true;
    }
    /**
     * 批量升级班级科目教师分配到新的年级：批量复制关系表，注意重复执行时候不得产生重复数据
     * @param upGradeRise:sourceclassids 班级ids列表 targetGradeId 目标年级id
     * @return
     */
    @Override
    public boolean upGradeRiseRelClassSubjectTeacher2NewGrade(UpGradeRise upGradeRise){
        return true;
    }
    /**
     * 批量升级学生分班情况升级到新的年级：批量复制关系表，注意重复执行时候不得产生重复数据
     * @param upGradeRise:sourceclassids 班级ids列表 targetGradeId 目标年级id
     * @return
     */
    @Override
    public boolean upGradeRiseRelClassStudent2NewGrade(UpGradeRise upGradeRise){
        return true;
    }
    /**
     * 批量升级教学计划到新的年级：批量复制教学计划数据表(含子表，含关系表)，注意复制去年同期数据
     * @param upGradeRise:sourceclassids 班级ids列表 targetGradeId 目标年级id
     * @return
     */
    @Override
    public boolean upGradeRiseCouCoursePlan2NewGrade(UpGradeRise upGradeRise){
        return true;
    }
    /**
     * 批量升级课程表到新的年级：批量复制课数据表(含子表，含关系表)，注意复制去年同期数据/或上一个学期的数据
     * @param upGradeRise:sourceclassids 班级ids列表 targetGradeId 目标年级id
     * @return
     */
    @Override
    public boolean upGradeRiseCouCourseArrange2NewGrade(UpGradeRise upGradeRise){
        return true;
    }
    /**
     * 批量根据班级科目教师分配更新课程表中的老师：批量更新修改课数据中的任课老师表(含子表，含关系表)，注意根据关系表的学期学年、班级信息，找到对应班级对应的课表进行批量更新
     * @param relClassSubjectTeacherList
     * @return
     */
    @Override
    public boolean upGradeRiseUpdateCourArraAtom2NewTeacherByRelClassSubjectTeacher(List<RelClassSubjectTeacher> relClassSubjectTeacherList){
        return true;
    }
}
